\documentclass[a4paper,10pt]{article}
%\usepackage[left=3cm,top=5cm,right=3cm,bottom=4cm,head=4cm,includefoot]{geometry}
\usepackage{textcomp}
\usepackage{graphicx}
\usepackage{listings}
\usepackage{multicol}
\usepackage[utf8]{inputenc}
\usepackage[spanish]{babel}
\usepackage{pdfpages}	



\title{		\textbf{Trabajo Práctico 1: Conjunto de instrucciones MIPS
}}

\author{	Rial Sebastián, \textit{Padrón Nro. -----}                     \\
            \texttt{ riseba@gmail.com }                                             \\[2.5ex]
			Sorrentino Luciano, \textit{Padrón Nro. -----}                     \\
            \texttt{ lucho0s@gmail.com }                                              \\[2.5ex]
            Quiroga,Sergio Darío, \textit{Padrón Nro. 90101}                     \\
            \texttt{ dario.quiroga@hotmail.com }                                              \\[2.5ex]
            \normalsize{1er. Cuatrimestre de 2013}                                      \\
            \normalsize{66.20 Organización de Computadoras  $-$ Práctica Jueves}  \\
            \normalsize{Facultad de Ingeniería, Universidad de Buenos Aires}            \\
       }

\date{Fecha de entrega: 2 de Mayo del 2013}



\begin{document}

\maketitle
\thispagestyle{empty}   % quita el nmero en la primer pgina


\newpage
\section{Introducción y objetivo}

El objetivo del trabajo práctico es familiarizarse con la programación en assembler MIPS y con la ABI(Application Binary Interface). Se desarrolará un programa en c + assembly MIPS. Finalmente, se compararán y obtendrán conclusiones de los tiempos de ejecución del programa en diferentes circunstancias.



\newpage
\section{Descripción}

Se utilizará el programa GXemul para simular una máquina de arquitectura MIPS, sobre ella se correrá una versión reciente del sistema operativo NetBSD.

El programa a desarrollar permitirá ordenar las palabras, de uno o más archivos, utilizando los algoritmos shellsort o bubblesort, según corresponda.

Se codificarán versiones en c de bubblesort y shellsort para obtener conclusiones. También se codificará una versión del shellsort en assembly MIPS y se comparará el desempeño de ésta con la correspondiente versión en c.

\newpage
\section{Diseño}

La implementación del programa fue dividida en varios módulos. Empezando con el {\em main} el cual a partir de los parámetros recibidos determina si es necesario mostrar la ayuda, versión, cuál algoritmo de ordenamiento se utilizará y si va a recibir la entrada de datos por stdin o archivos. Además, el {\em main} será el encargado de la apertura y cierre de archivos (cuando sea necesario) y del reporte de errores. La impresión de errores y de los mensajes necesarios es llevada a cabo por el módulo {\em errors}.
$El módulo {\em Validation} se encargará de la validación de ciertos parámetros de entrada y del chequeo de errores en los archivos de entrada/salida.$

El siguiente módulo es {\em lista}, éste contiene la implementación de una estructura de lista enlazada, utilizada auxiliarmente dentro del programa.

El módulo {\em parser} se ocupa de parsear los streams de entrada y obtener las palabras que serán ordenadas.

Los módulos {\em shellsort} y {\em bubblesort} contienen la implementación de los algoritmos de shellsort y bubblesort respectivamente.

El módulo {\em utils} tiene funciones auxiliares, necesarias durante el programa.

\subsection{Procesamiento de Stdin y Procesamiento de Archivo}

Para el parseo de los streams se recorre caracter por caracter el mismo y se determina, por cada caracter, si éste se trata de un carácter válido o de un separador de palabra. Si se trata de un caracter válido se agregará a un string temporal. Al encontrar un separador, se almacenará la palabra del string temporal en la lista a ordenar (si no estaba en ella).

%\newpage
\section{Modo de Uso}

La aplicación consta de los siguientes archivos:

\begin{multicols}{3}
	\begin{itemize}
	 \item BinaryToOctal.c
	 \item BinaryToOctal.h
	 \item OctalToBinary.c
	 \item OctalToBinary.h
	 \item Controlar.c
	 \item Controlar.h
	 \item Help.c
	 \item Help.h
	 \item Errores.c
	 \item Errores.h
	 \item Validation.c
	 \item Validation.h
	 \item main.c
	\end{itemize}
\end{multicols}

Los pasos que seguimos para poder ejecutar la aplicación fueron los siguientes:

	\begin{itemize}
	 \item instalamos el programa GXemul para correr una versión del sistema operativo NetBSD (sistema operativo guest). El software fue provisto por la cátedra
	 \item copiamos los archivos correspondientes a la aplicación en el sistema operativo guest
	 \item compilamos y corrimos la aplicación
	\end{itemize}

A continuación, contamos detalladamente los pasos anteriormente mencionados.

\subsection{Instalación de GXemul}
\label{InstalacionGXemul}

Para tener el ambiente necesario para correr la aplicación:

	\begin{itemize}
	 \item descargamos y descomprimimos el archivo con los siguientes archivos comprimidos:
		\begin{itemize}
		 \item gxemul (GXemul)
		 \item netbsd-pmax.img (una imagen del sistema operativo NetBSD)
		\end{itemize}
	 \item desde consola nos posicionamos en el directorio donde descomprimimos los archivos que habíamos descargado y ejecutamos gxemul.

\begin{verbatim}
cd /home/directorio_ubicado_gxemul
./gxemul -e 3max -d netbsd-pmax.img
\end{verbatim}

	 \item con las líneas anteriores empieza a ejecutarse el sistema operativo guest. Cuando llegue a la fase de login, escribimos:

\begin{verbatim}
usuario: root
password: orga6620
\end{verbatim}

	 \item luego, creamos un usuario en el sistema operativo guest llamado gxemul:

\begin{verbatim}
useradd -m gxemul
passwd gxemul
(escribimos pass)
\end{verbatim}

	\end{itemize}

\subsection{Pasaje de Archivos}

Por comodidad nuestra, la implementación del comando {\em od} fue realizada en el sistema operativo host y no directamente en el guest. Por lo tanto, fue necesario pasar una copia de la aplicación a este último. Para ello:
	 \begin{itemize}
	  \item abrimos una nueva consola en el sistema operativo host y nos pasamos a superusuario. Creamos un usuario llamado gxemul procediendo de la misma manera explicada en la sección \ref{InstalacionGXemul}.
	  \item luego, ejecutamos el siguiente comando

\begin{verbatim}
ifconfig lo:0 172.20.0.1
\end{verbatim}

	  \item volviendo a la consola que habamos dejado abierta, en el paso anterior, del sistema operativo guest, colocamos la siguiente lnea:

\begin{verbatim}
ssh -R 2222:127.0.0.1:22 gxemul@172.20.0.1 
\end{verbatim}

	  \item nos solicitar la password del usuario gxemul del sistema operativo host, la ingresamos y presionamos enter.
	  \item en otra consola del sistema operativo host escribimos:

\begin{verbatim}
ssh -p 2222 gxemul@127.0.0.1
\end{verbatim}

	  \item y nos solicitar la contraseña del usuario gxemul del sistema operativo guest. Una vez habiendo ingresado la pass correctamente, empezar a correr NetBSD, cuando llegue a la fase de login ingresamos con el usuario gxemul. Deberamos estar viendo algo como los que mostramos en la Figura \ref{fig0301} de abajo. Para ms comodidad escribimos la línea: {\em bash}

\begin{figure}[htb]
	\begin{center}
		\noindent \includegraphics[scale=0.5]{./Imagen/imagen03.png}
	\end{center}
\caption{Login del usuario gxemul en el sistema operativo guest}
\label{fig0301}
\end{figure}

	  \item luego, abrimos nuevamente otra consola del sistema operativo host para pasar los archivos mediante la siguiente línea:

\begin{verbatim}
scp -P 2222 -r /home/dir_del_tp/ 
 gxemul@127.0.0.1:/home/gxemul/dir_donde_copia
\end{verbatim}

Ejemplo:

\begin{verbatim}
scp -P 2222 -r /home/usarioHost/Documentos/Tp0/
 gxemul@127.0.0.1:/home/gxemul
\end{verbatim}
	 \end{itemize}

\subsection{Compilación y Ejecución del Programa}
 
 Para poder compilar la aplicación:

\begin{verbatim}
gcc -Wall -o tp0 Help.c Validation.c OctalToBinary.c BinaryToOctal.c Errores.c main.c


\end{verbatim}

 donde tp0 es el nombre del ejecutable. Para ejecutarlo, y ver la ayuda escribirmos:

\begin{verbatim}
./tp0 -h 
\end{verbatim}

La salida por pantalla esperada la vemos en la Figura \ref{fig0302}.

\begin{figure}[htb]
	\begin{center}
		\noindent \includegraphics[scale=0.5]{./Imagen/imagen03-ayuda.png}
	\end{center}
\caption{Salida de pantalla esperada cuando ingresamos por consola "./tp0 -h" - "./tp0 --help"}
\label{fig0302}
\end{figure}

Ms adelante (en la sección \ref{Pruebas}), veremos como utilizar el programa con otros parámetros.

%\newpage
\section{Mensajes de Error}

Para el manejo de los errores que podran llegar a ocurrir con los archivos que pasamos como parámetros, utilizamos los códigos y mensajes de error definidos por la implementación de C y del sistema operativo correspondiente a los fines de lograr mayor portabilidad. Estos códigos son grabados por la función stat en la variable {\em errno} en caso de producirse un error. Aquí presentaremos el listado de dichos errores y los mensajes que serán enviados por la salida de error estandar ({\em stderr}).

\subsection{Error de Acceso}
\noindent
\textbf{Cdigo de Error:} EACCES(13)\\
\textbf{Mensaje de error:} Permission denied\\

\noindent Este error ocurre cuando no podemos acceder a un archivo porque no tenemos los permisos necesarios.


\subsection{Error de Manejo de Links Simblicos}
\noindent
\textbf{Cdigo de error:} ELOOP(40)\\
\textbf{Mensaje de error:} Too many levels of symbolic links\\

\noindent Este error ocurre cuando se encuentran muchos links simbólicos durante el recorrido del path.

\subsection{Error por Nombre Largo}
\noindent 
\textbf{Cdigo de error:} ENAMETOOLONG(36)\\
\textbf{Mensaje de error:} File name too long\\

\noindent Este error se produce cuando el nombre del archivo supera el tamaño máximo permitido por el sistema operativo.

\subsection{Error en la Dirección}
\noindent
\textbf{Cdigo de Error:} ENOENT(2)\\
\textbf{Mensaje de error:} No such file or directory\\

\noindent Este error se produce cuando el archivo solicitado no existe.

\subsection{Error de Directorio}
\noindent
\textbf{Cdigo de error:} ENOTDIR(20)\\
\textbf{Mensaje de error:} Not a directory\\

\noindent Este error ocurre cuando en la ruta del archivo se confunde el nombre de un archivo con el de un directorio.

\subsection{Error de Overflow}
\noindent
\textbf{Cdigo de error:} EOVERFLOW(75)\\
\textbf{Mensaje de error:} Value too large for defined data type\\

\noindent Este error ocurre cuando tratamos de acceder a un archivo de mayor tamaño del que la aplicación es capaz de manejar.


\subsection{Error al pedir Memoria}
\noindent
\textbf{Código de Error:} ERROR\_MEMORIA(2)\\
\textbf{Mensaje de error:} Error al pedir memoria.\\

\noindent Este error se produce cuando falla la función calloc de C al alocar memoria.

\subsection{Error al operar con Archivos}
\noindent
\textbf{Código de Error:} ERROR\_ARCHIVO(3)\\
\textbf{Mensaje de error:} (depende de que función produjo el error)\\

\noindent Este error se produce cuando falla alguna de las siguientes funciones: fopen, fclose de C.

\subsection{Error al realizar una escritura}
\noindent
\textbf{Código de Error:} ERROR\_ESCRITURA(4)\\
\textbf{Mensaje de error:} Error al escribir.\\

\noindent Este error se produce cuando no se escribieron en stdout o en el archivo todos los bytes esperados.

\subsection{Error al realizar una lectura}
\noindent
\textbf{Código de Error:} ERROR\_LECTURA(5)\\
\textbf{Mensaje de error:} (depende).\\

\noindent Este error se produce cuando no se pudieron leer, ya sea de stdin o de archivo, todos los bytes esperados.

\subsection{Error por delimitador invalido}
\noindent
\textbf{Código de Error:} ERROR\_LIMITADOR(6)\\
\textbf{Mensaje de error:} Delimitador invalido, verificar de incluir el correcto delimitador en la ejecucion del programa.\\


\noindent Este error se produce cuando asigna un delimitador invalido.

\subsection{Error por argumento invalido}
\noindent
\textbf{Código de Error:} ERROR\_ARGUMENTO(6)\\
\textbf{Mensaje de error:} Parametro invalido, debe ser del estilo: -l <numero positivo>.\\

\noindent Este error se produce cuando asigna un argumento invalido.

\subsection{Error por conversión inválida}
\noindent
\textbf{Código de Error:} ERROR\_CONVERSION(6)\\
\textbf{Mensaje de error:} Por favor elegir solo un modo de conversion, -b o -O\\

\noindent Este error se produce cuando asigna más de un modo de conversión a la vez
\newpage 

\section{Pruebas}
\label{Pruebas}

En esta sección, mostramos algunas de las pruebas que realizamos para mostrar los resultados obtenidos por el programa. Hemos utilizado, para las pruebas, los archivos disponibles en el directorio test.

\subsection{Prueba 1}
El script lleva a cabo las siguientes tareas:
    
Se compila el programa TP0, luego muestra el contenido del archivo prueba.
Se convierte dicho archivo a octal con el método programado en este trabajo
y se guarda en un archivo, luego se compara este archivo con la conversión
a octal del mismo archivo prueba.
Finalmente se muestra por pantalla el resultado de dicha comparación.
\newline

\begin{figure}[htb]
	\begin{center}
		\noindent \includegraphics[width=1.0\textwidth]{./Imagen/prueba1.jpg}
	\end{center}
\caption{Resultado de correr el script de prueba1}
\label{fig0601}
\end{figure}
\newpage

\subsection{Prueba 2}
El script lleva a cabo las siguientes tareas:

Se compila el programa TP0, se convierte a octal un archivo binario descargado
de internet llamado Ares (3 mb), se convierte a binario el archivo octal
obtenido, con el fin de recuperar el archivo original, se muestra por pantalla
el resultado de comparar ambos archivos binarios (el binario original con
el obtenido luego de la doble conversión).
 
 \begin{figure}[htb]
	\begin{center}
		\noindent \includegraphics[width=1.0\textwidth]{./Imagen/prueba2.jpg}
	\end{center}
\caption{Resultado de correr el script de prueba2}

\end{figure}
\newpage
 
 \subsection{Prueba 3}
El script lleva a cabo las siguientes tareas:
Se compila el programa TP0, se genera pseudo-aleatoriamente una secuencia
de bytes (urandom de 10000000 bytes) y se guardan en un archivo, luego
se convierte este archivo a octal (utilizando la palabra {\em Delimiter} 
como delimitador y 4 octal bytes por línea) y después a binario nuevamente,
y se muestra el resultado de comparar ambos archivos binarios (el binario
original con el obtenido luego de la doble conversión).
 
  \begin{figure}[htb]
	\begin{center}
		\noindent \includegraphics[width=1.0\textwidth]{./Imagen/prueba3.jpg}
	\end{center}
\caption{Resultado de correr el script de prueba3}
\label{fig0601}
\end{figure}

 \subsection{Prueba 4}
El script realiza las siguientes tareas:
Se compila el programa TP0, se convierte el archivo ares de binario a octal,
con el delimitador {\em Delimiter}, luego se intenta convertir de octal a binario para recuperar el archivo
 riginal pero con delimitador diferente {\em otroDelimiter},razón por la cual se obtiene un error.
 
\begin{figure}[htb]
	\begin{center}
		\noindent \includegraphics[width=1.0\textwidth]{./Imagen/prueba4.jpg}
	\end{center}
\caption{Resultado de correr el script de prueba4}
\end{figure}
 
 \subsection{Prueba 5}
El script realiza las siguientes tareas:
Se compila el programa TP0, y se ejecuta TP0 en modo octal a binario con
dos octal byes por linea y un espacio en blanco como delimitador, como
no se especifica ninguna entrada ni salida, se toman las entradas y salidas
por defecto, por lo cual se podrán ingresados los datos por la consola
(en este caso se ingresa {\em Hola Mundo} y los resultados se mostrarán por la consola.
 
 \begin{figure}[htb]
	\begin{center}
		\noindent \includegraphics[width=1.0\textwidth]{./Imagen/prueba5.jpg}
	\end{center}
\caption{Resultado de correr el script de prueba5}
\end{figure}
 
  \subsection{Prueba 6}
El script realiza las siguientes tareas:
Se compila el programa TP0, y se intenta ejecutar TP0 con la opción -l {\em k},
es decir ,con una cantidad de k octal bytes por línea, , lo cual arrojará un error 
ya que la cantidad de octal bytes por línea debe ser un número entero positivo ó 0 y 
este es un caracter "k".
 
 \begin{figure}[htb]
	\begin{center}
		\noindent \includegraphics[width=1.0\textwidth]{./Imagen/prueba6.jpg}
	\end{center}
\caption{Resultado de correr el script de prueba6}
\end{figure}

\newpage 

  \subsection{Prueba 7}
El script realiza las siguientes tareas:
Se compila el programa TP0 y se intenta ejecutar TP0 en modo binario a octal,
con un archivo de entrada inexistente, por lo que se arrojará un error 
 \begin{figure}[htb]
	\begin{center}
		\noindent \includegraphics[width=1.0\textwidth]{./Imagen/prueba7.jpg}
	\end{center}
\caption{Resultado de correr el script de prueba7}
\end{figure}


 
\newpage 


\section{Código Fuente}

A continuación, presentamos el cdigo escrito en C del programa que implementamos.

\subsection{main.c}

 \input{./CodC/main.c}

\subsection{BinaryToOctal.h}

 \input{./CodC/BinaryToOctal.h}

\subsection{BinaryToOctal.c}

 \input{./CodC/BinaryToOctal.c}
  
\subsection{OctalToBinary.h}

  \input{./CodC/OctalToBinary.h}

\subsection{OctalToBinary.c}

  \input{./CodC/OctalToBinary.c}

\subsection{Help.h}

  \input{./CodC/Help.h}

\subsection{Help.c}

  \input{./CodC/Help.c}
 
\subsection{Validation.h}

  \input{./CodC/Validation.h}

\subsection{Validation.c}

   \input{./CodC/Validation.c}

\subsection{Errores.h}

  \input{./CodC/Errores.h}

\subsection{Errores.c}

   \input{./CodC/Errores.c}

\subsection{Constants.h}

   \input{./CodC/Constants.h}

\newpage

\section{Código Fuente Generado por MIPS32}

A continuación, presentamos el código en Assembler del programa que implementamos.

\subsection{main.s}

\begin{multicols}{2}
	\input{./CodMIPS/main.s}
\end{multicols}

\subsection{BinaryToOctal.s}

\begin{multicols}{2}
	\input{./CodMIPS/BinaryToOctal.s}
\end{multicols}

\subsection{OctalToBinary.s}

\begin{multicols}{2}
	\input{./CodMIPS/OctalToBinary.s}
\end{multicols}

\subsection{Help.s}

\begin{multicols}{2}
	 \input{./CodMIPS/Help.s}
\end{multicols}

\subsection{Validation.s}

\begin{multicols}{2}
	 \input{./CodMIPS/Validation.s}
\end{multicols}
	

\newpage
\section{Conclusiones}

Comprobamos la portabilidad del mismo en dos arquitecturas diferentes (MIPS e INTEL). Por otro lado, profundizamos el conocimiento de los file descriptors {\em stdin}, {\em stdout} y {\em stderr}, así como también su manejo. Con respecto al código, observamos las diferencias en cantidad de instrucciones entre un lenguaje de bajo nivel como es Assembler y uno de alto nivel como es el lenguaje C.
Por último, pudimos interactuar con el emulador GXemul que nos permitió simular una computadora con arquitectura MIPS.

\newpage
\includepdf[pages=-,scale=1,nup=1x1]{tp0-2012-2q.pdf}

\end{document}
